Modern software is typically created with a great deal of computer automated assistance. Such assistance is commercially available in a variety of software development environments. For example, MICROSOFT'S VISUAL STUDIO®, BORLAND'S C++BUILDER®, METROWERK'S CODE WARRIOR®, and IBM'S WEBSPHERE STUDIO® are all products presently available to assist in the software creation. Such products provide a range of useful functions, such as coordinating communications between multiple developers working together on large projects, assisting in the actual writing of source code, assisting in specifying how a source code file will be compiled, and providing compilers that convert a source code file into executable files.
A typical software development environment is illustrated in FIG. 1a. As suggested by the figure, a central server 100 coordinates the efforts of a number of developers 110, 115, 120, 125. A developer is a person involved in implementing a software application. In FIG. 1a, the developers 110, 115, 120, 125 are depicted as client computers, because the developer will likely use a client computer as a tool in software development. Developer actions include instructions carried out by a developer's computer. The developers 110, 115, 120, 125 may each have a variety of responsibilities in implementing aspects of a large software application. It is important that these aspects work together and do not unduly interfere with the operation of the application under development. It is also preferable to ensure centralized control over the application, so that developers 110, 115, 120, 125 cannot inadvertently alter the application without approval through the proper channels. Without such centralized control, the development environment can quickly become one in which there are many copies of an application, each with differing features, and it becomes impossible to move forward with production.
Thus the central server 100 is frequently called a “Source Code Control” (SCC) engine 100. The means by which most SCC engines 100 coordinate development is through sync and check-in procedures. When a developer, e.g. 110, first retrieves existing software under development from the SCC engine 100, it is called a sync 111. A sync creates a copy of the application on the developer's client computer 110. This provides the developer 110 with an official copy of the application under development, so he can work with the existing features of the application.
A check-in 112 occurs when the developer 110 returns his or her modifications to the SCC engine 100; and thereby updates the official version of the application under development. A set of modifications may be subject to review prior to check-in 112. If the modifications made by developer 110 conflict with other modifications, e.g. those of developer 115, then the modifications may have to be scrapped. Developer 110 may be required to rework the source code that he or she originally wrote. There are numerous other reasons approval of developer's 110 work may be denied, preventing check-in 112. For example, the modifications may create a security issue, or they may not meet design requirements.
SCC engines 100 may save copies of an application under development after every check-in. If a problem is discovered, the source of the problem can be uncovered by backtracking through the various saved versions of the application. Diagnostic tests can be run against applications both with and without a set of modifications. Also, if a developer 110 inadvertently damages a client copy of an application, he or she can retrieve the latest version, or any version, of the application via a sync 111 operation with the SCC engine 100. Another benefit of this arrangement is insurance against massive team-wide failures. A developer 110 can only damage a client copy of the application. A check-in 112 that causes widespread damage to an official SCC engine 100 version of an application will not lead to massive failure, because the development team can simply return to a version of the application prior to check-in 112.
However, a developer 110 may go several weeks or longer prior to checking in modifications. In this time, a developer 110 may do significant amounts of work. If this work is inadvertently damaged or lost, a developer may experience a substantial setback regardless of the availability of the SCC engine 100 to supply the latest official version of an application. Moreover, the potential solution of saving multiple copies, as work progresses, on a developer's 110 client device is inadvisable in the context of software development. Just as with the potential problem of copy proliferation in a development team, a single developer will typically avoid making multiple copies of an application under development, because copies will quickly proliferate, causing headaches in determining which copy is which and potentially supplying erroneous copies for check-in 112.
FIG. 1b illustrates an exemplary developer work schedule in the form of a timeline. The timeline begins with a sync 151 and ends with a check-in 196. During the first week, a developer begins work on an aspect of an application under development to which he or she is assigned. The developer devotes significant time to the assignment, and generates a substantial portion 152 of the requisite source code. This first substantial portion 152 of source code will be referred to as modifications 152. For the purpose of this document, a modification is both a creation of and an alteration to any portion of software under development.
Later in the first week, the developer discovers a potential improvement to modifications 152, and goes about implementing modifications 153. Modifications 153 include removing parts of modifications 152, replacing some of modifications 152 with alternative lines of source code, and adding some source code to modifications 152.
In the second week, the developer again discovers a potential improvement to modifications 152, and goes about implementing modifications 161. Modifications 161 include removing parts of modifications 152 and modifications 153, replacing some of modifications 152 with alternative lines of source code, and adding some source code to modifications 152.
Later in the second week, the developer discovers that modifications 153 may actually lead to problems later on in the development process. After consideration, the developer determines that by making modifications 162 that replace most of modifications 153, the advantages of 153 can be retained without the potential problems down the road. So developer makes modifications 162, which replace much of 153.
In week three, developer makes modifications 171, which include several minor additional changes to clean up the work done so far prior to seeking approval for check-in 172. As this time line shows, by the time of submission for approval prior to check-in 172, a developer's work may have undergone a rather convoluted process of modifications.
The timeline is further complicated by the possibility that approval will be denied, as in 181. As part of such a denial, 181, a developer may be asked to rework specific portions of prior modifications in order to comply with the development goals. Perhaps, even though the developer's modifications 162 improved the software under development, these modifications presented unacceptable conflicts with the work of other team members, and so the developer was required to remove modifications 162 and replace them with a non-conflicting way to carry out the same function.
Later in Week 4, the developer discovers 182 that modifications 153, as originally written, would satisfy the requirements of the team. However, modifications 153 were overwritten by modifications 162, and according to good development practice, no copy of modifications 153 was saved. The developer is forced to redo the work that was previously done in implementing modifications 153. In the exemplary timeline, the developer grudgingly does so in week 5, at the expense of spending precious time that could be spent on other software development. Finally, the developer resubmits his or her work for approval for check-in, and obtains approval 192.
Thus, while the present state of the art allows developers to backtrack to a previous official version of software, this is often inadequate, especially where significant work is done between check-ins. The undesirability of saving multiple copies of software under development makes the loss of work conducted between check-ins more likely, presenting an additional hurdle to potential solutions for the problem.
Some attempts to avoid the problems discussed above have been implemented in current software development environments. For example, refer to FIG. 1c. This figure presents an exemplary display surface 129, such as a computer screen on one of the developer 110, 115, 120, 125 computers in FIG. 1a. The display surface shows a Graphical User Interface (GUI) 130 for a typical software development environment that is presumably running on a corresponding computer. As can be readily observed in FIG. 1c, the GUI 130 has standard drop-down menus such as file 131, edit 132, view 133, and a plurality of buttons 135, 136, 137, etc. for easy access to frequently used functions. In addition, the GUI 130 gives a workspace 128 in which source code can be modified.
One function of present software development environment GUIs 130 may be an Undo 138 and/or Redo 139 function. This allows a developer who mistakenly modifies a file to serially remove previous modifications. If the developer removes to many modifications, he or she may be able to re-insert modifications automatically by selecting redo 139. However, undo 138 and redo 139 are severely limited in present software development environments, and do not provide significant help to developers who find themselves in the situation described with reference to FIG. 1b. 
First, undo 138 and redo 139 functions are available only on a session-by-session basis. In other words, modifications made in a first software development environment session cannot be undone with undo 138 after that session is closed. Once a software development environment process is ended, the stack of undo/redo data is discarded. Therefore undo/redo would not help the developer in the situation of FIG. 1b if that developer closed the development tool session at any point between 162 and 191.
Second, undo 138 and redo 139 are only accessible serially. If it is discovered that a modification that was made should be removed using undo 138, all modifications subsequent to the removed modification must also be removed with undo 138. For example, referring to FIG. 1b, the minor modifications 171 must be removed if a developer also wishes to remove modifications 162. The same is true of redo 139. If too many modifications are undone because a desirable modification has been removed, redo 139 can be used but will only recreate the desired modification after recreating all intervening modifications. In the context of software development, where the various modifications are highly interrelated, the costs of inserting or removing modifications contrary to the desires of the developer are high.
In light of the heretofore unacknowledged deficiencies in the art described above, there is a need in the industry to provide better management of software modifications between check-ins.